/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package com.alxbrendmaquinarias.controller.maintenance;

import com.alxbrendmaquinarias.model.Category;
import com.alxbrendmaquinarias.model.Mark;
import com.alxbrendmaquinarias.model.Product;
import com.alxbrendmaquinarias.model.UnitType;
import com.alxbrendmaquinarias.service.CategoryService;
import com.alxbrendmaquinarias.service.MarkService;
import com.alxbrendmaquinarias.service.ProductService;
import com.alxbrendmaquinarias.service.UnitTypeService;
import com.alxbrendmaquinarias.util.faces.FacesUtil;
import java.io.Serializable;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.application.FacesMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/**
 *
 * @author Max
 */
@Controller
public class ProductController implements Serializable{
    /**
     *
     */
    private static final long serialVersionUID = 1L;
    @Autowired
    ProductService productService;
    @Autowired
    MarkService markService;
    @Autowired
    CategoryService categoryService;
    @Autowired
    UnitTypeService unitTypeService; 
    
    //ATRIBUTOS
    private List<Product> listProducts;
    private List<Mark> listMark;
    private List<Category> listCategory;
    private List<UnitType> listUnitType;
    ///MAINTENANCE
    private Product product = new Product();
    private Mark mark = new Mark();
    private UnitType unitType = new UnitType();
    private Category category = new Category();

    //INICIANDO VALORES
    public void initValuesProduct() {
        listProducts = null;
        product = new Product();
    }
    
    public void initValuesMark() {
        listMark = null;
        mark = new Mark();
    }
    
    public void initValuesCategory() {
        listCategory = null;
        category = new Category();
    }
    
    public void initValuesUnitType() {
        listUnitType = null;
        unitType = new UnitType();
    }

    public ProductController() {
        //generateProductId();
    }
    
    
    
    //METODOS TRANSANCIONALES
    
    public void saveOrUpdateProduct() throws Exception {
        if(product.getId() == null){
            productService.save(product);
            System.out.println("Mark: " + product.getMarkId());
            FacesUtil.addMessage("Guardado con éxito...", null, FacesMessage.SEVERITY_INFO);
            initValuesProduct();
        } else {
            productService.update(product);
            FacesUtil.addMessage("Actualizado con éxito...", null, FacesMessage.SEVERITY_INFO);
            initValuesProduct();
        }
    }
    
    public void deleteProduct(Product product)throws Exception{
        try {
            productService.remove(product);
            FacesUtil.addMessage("Eliminado", "Se encuentra eliminado...", FacesMessage.SEVERITY_INFO);
            initValuesProduct();
        } catch (Exception ex) {
            FacesUtil.addMessage("IMPOSIBLE ELIMINAR", "El producto está siendo utilizado en otro proceso", FacesMessage.SEVERITY_ERROR);
            initValuesProduct();
        }
    }
    /*
    public void generateProductId()
    {
        String productId;
        String tempId;
        if(product==null)
        {
            productId = productService.maxProductId().get(0).getProductId();
            tempId = productId+1;
            product.setProductId(tempId);
        }
    }*/
    
    /*save or update*/
    public void saveOrUpdateMark() throws Exception {
        if(mark.getId() == null){
            markService.save(mark);
            FacesUtil.addMessage("Guardado con éxito...", "Se guardo una Marca", FacesMessage.SEVERITY_INFO);
            initValuesMark();
        } else {
            markService.update(mark);
            FacesUtil.addMessage("Actualizado con éxito...", "Se actualizó la Marca", FacesMessage.SEVERITY_INFO);
            initValuesMark();
        }
    }
      
    public void deleteMark() {
        try {
            markService.remove(mark);
            FacesUtil.addMessage("Eliminado", "Se encuentra eliminado...", FacesMessage.SEVERITY_INFO);
            initValuesMark();
        } catch (Exception ex) {
            FacesUtil.addMessage("IMPOSIBLE ELIMINAR", "El producto está siendo utilizado en otro proceso", FacesMessage.SEVERITY_ERROR);
            initValuesMark();
        }
    }
    
    public void saveOrUpdateCategory() throws Exception {
        if(category.getId() == null){
            categoryService.save(category);
            FacesUtil.addMessage("Guardado con éxito...", "Se guardo una Categoría", FacesMessage.SEVERITY_INFO);
            initValuesCategory();
        } else {
            categoryService.update(category);
            FacesUtil.addMessage("Actualizado con éxito...", "Se actualizó la Categoría", FacesMessage.SEVERITY_INFO);
            initValuesCategory();
        }
    }
    
    public void deleteCategory() {
        try {
            categoryService.remove(category);
            FacesUtil.addMessage("Eliminado", "Se encuentra eliminado...", FacesMessage.SEVERITY_INFO);
            initValuesCategory();
        } catch (Exception ex) {
            FacesUtil.addMessage("IMPOSIBLE ELIMINAR", "La categoría está siendo utilizado en otro proceso", FacesMessage.SEVERITY_ERROR);
            initValuesCategory();
        }
    }
    
    public void saveOrUpdateUnitType() throws Exception {
        if(unitType.getId() == null){
            unitTypeService.save(unitType);
            FacesUtil.addMessage("Guardado con éxito...", "Se guardo un Tipo de Unidad", FacesMessage.SEVERITY_INFO);
            initValuesUnitType();
        } else {
            unitTypeService.update(unitType);
            FacesUtil.addMessage("Actualizado con éxito...", "Se actualizó el Tipo de Unidad", FacesMessage.SEVERITY_INFO);
            initValuesUnitType();
        }
    }
    
    public void deleteUnitType() {
        try {
            unitTypeService.remove(unitType);
            FacesUtil.addMessage("Eliminado", "Se encuentra eliminado...", FacesMessage.SEVERITY_INFO);
            initValuesUnitType();
        } catch (Exception ex) {
            FacesUtil.addMessage("IMPOSIBLE ELIMINAR", "El tipo de unidad está siendo utilizado en otro proceso", FacesMessage.SEVERITY_ERROR);
            initValuesUnitType();
        }
    }
    
    //METODOS GETTER Y SETTER
    public List<Mark> getListMark() throws Exception {
        if( listMark == null ){
            listMark = markService.list("Mark.findAll");
        }
        return listMark;
    }

    public void setListMark(List<Mark> listMark) {
        this.listMark = listMark;
    }

    public List<Category> getListCategory() throws Exception{
        if(listCategory == null)
        {
            listCategory = categoryService.list("Category.findAll");
        }
        return listCategory;
    }

    public void setListCategory(List<Category> listCategory) {
        this.listCategory = listCategory;
    }

    public List<UnitType> getListUnitType() throws Exception{
        if(listUnitType == null)
        {
            listUnitType = unitTypeService.list("UnitType.findAll");
        }
        return listUnitType;
    }

    public void setListUnitType(List<UnitType> listUnitType) {
        this.listUnitType = listUnitType;
    }

    public List<Product> getListProducts() throws Exception {
        if(listProducts == null) {
            listProducts = productService.list("Product.findAll");
        }
        return listProducts;
    }

    public void setListProducts(List<Product> listProducts) {
        this.listProducts = listProducts;
    }

    public Product getProduct() {
        return product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    public Mark getMark() {
        return mark;
    }

    public void setMark(Mark mark) {
        this.mark = mark;
    }

    public UnitType getUnitType() {
        return unitType;
    }

    public void setUnitType(UnitType unitType) {
        this.unitType = unitType;
    }

    public Category getCategory() {
        return category;
    }

    public void setCategory(Category category) {
        this.category = category;
    }
    
    
}
